home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Disktools / SCSI List / source / Scsi.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-09-27  |  28.7 KB  |  840 lines
  1. /*
  2.  * SCSI.C - Show SCSI Devices
  3.  *
  4.  *   $VER: SCSI.C 1.2 (7.4.96)
  5.  *
  6.  * (c) Copyright 1996 Richard Sellens.  All rights reserved.
  7.  *
  8.  * This software is provided as-is and is subject to change; no warranties
  9.  * are made.  All use is at your own risk.  No liability or responsibility
  10.  * is assumed.
  11.  *
  12.  * Release  Date     Change
  13.  *
  14.  * 1.0      02/02/96 Initial Program
  15.  * 1.1      31/03/96 Made SCSI Device string area longer
  16.  * 1.2      07/04/96 Added ability to select unit from List for display,
  17.  *                   Added Locale support for most strings 
  18.  * 
  19.  */
  20.  
  21.  
  22. /*------------------------------------------------------------------------*/
  23.  
  24. #define INTUITION_IOBSOLETE_H
  25. #define CATCOMP_NUMBERS
  26. #define CATCOMP_BLOCK
  27. #define CATCOMP_CODE
  28. #define REG(x) register __ ## x
  29. #define ASM    __asm
  30. #define SAVEDS __saveds
  31.  
  32. #include <dos/dos.h>
  33. #include <exec/devices.h> 
  34. #include <exec/errors.h> 
  35. #include <exec/execbase.h>
  36. #include <exec/memory.h>
  37. #include <exec/types.h>
  38. #include <graphics/gfxmacros.h>
  39. #include <libraries/mui.h>
  40. #include <libraries/locale.h>
  41. #include <workbench/workbench.h>
  42.  
  43. #include <clib/alib_protos.h>
  44. #include <clib/asl_protos.h>
  45. #include <clib/dos_protos.h>
  46. #include <clib/exec_protos.h>
  47. #include <clib/graphics_protos.h>
  48. #include <clib/icon_protos.h>
  49. #include <clib/intuition_protos.h>
  50. #include <clib/locale_protos.h>
  51. #include <clib/muimaster_protos.h>
  52. #include <clib/utility_protos.h>
  53.  
  54. #include <stdlib.h>
  55. #include <string.h>
  56. #include <stdio.h>
  57.  
  58. #include <pragmas/asl_pragmas.h>
  59. #include <pragmas/dos_pragmas.h>
  60. #include <pragmas/exec_pragmas.h>
  61. #include <pragmas/graphics_pragmas.h>
  62. #include <pragmas/icon_pragmas.h>
  63. #include <pragmas/intuition_pragmas.h>
  64. #include <pragmas/locale_pragmas.h>
  65. #include <pragmas/muimaster_pragmas.h>
  66. #include <pragmas/utility_pragmas.h>
  67.  
  68. #include "Scsi_Cmd.h"
  69.  
  70. /*------------------------------------------------------------------------*/
  71.  
  72. void    Main(int argc, char **argv);
  73. void    BailOut(APTR app, char *str);
  74. void    gettooltypes(struct WBArg *);
  75. BOOL    InitClasses(void);
  76. void    ExitClasses(void);
  77. ULONG   ScsiList_New(struct IClass *, Object *, struct opSet *);
  78. ULONG   ScsiList_Cleanup(struct IClass *, Object *, Msg);
  79. ULONG   ScsiList_Setup(struct IClass *, Object *, Msg);
  80. void    ShowSCSI(char *);
  81. void    ShowScsi_exit(long code, char *);
  82. void    ListDevices(char *);
  83. UBYTE   *id2string(int ,IDTOSTRING * idtable);
  84. STRPTR  GetString(struct LocaleInfo *li, LONG stringNum);
  85.  
  86. /*------------------------------------------------------------------------*/
  87.  
  88. extern  struct  Library         *DOSBase;
  89. extern  struct  ExecBase        *SysBase;
  90. extern  struct  GfxBase         *GfxBase;
  91. extern  struct  IntuitionBase   *IntuitionBase;
  92. struct  Library                 *LocaleBase;
  93. struct  Library                 *IconBase;
  94. extern  struct  Library         *UtilityBase;
  95. struct  Library                 *MUIMasterBase  = NULL;
  96.  
  97. /*------------------------------------------------------------------------*/
  98.  
  99. #include "Scsi_Locale.h" 
  100.  
  101. /*------------------------------------------------------------------------*/
  102.  
  103. #define USE_CD_ROM_BODY
  104. #define USE_CD_ROM_COLORS
  105. #include "CD_Rom.h"
  106.  
  107. #define USE_HARD_DRIVE_BODY
  108. #define USE_HARD_DRIVE_COLORS
  109. #include "Hard_Drive.h"
  110.  
  111.  
  112. #define USE_REMOVE_DRIVE_BODY
  113. #define USE_REMOVE_DRIVE_COLORS
  114. #include "Remove_Drive.h"
  115.  
  116.  
  117. #define USE_SCANNER_BODY
  118. #define USE_SCANNER_COLORS
  119. #include "Scanner.h"
  120.  
  121. #define USE_NULL_BODY
  122. #define USE_NULL_COLORS
  123. #include "Null.h"
  124.  
  125. #define USE_NOUNIT_BODY
  126. #define USE_NOUNIT_COLORS
  127. #include "NoUnit.h"
  128.  
  129. #define USE_SCSI_BODY
  130. #define USE_SCSI_COLORS
  131. #include "ScsiImage.h"
  132.  
  133. /*------------------------------------------------------------------------*/
  134.  
  135. #ifndef MAKE_ID
  136. #define MAKE_ID(a,b,c,d) ((ULONG) (a)<<24 | (ULONG) (b)<<16 | (ULONG) (c)<<8 | (ULONG) (d))
  137. #endif
  138.  
  139. #define MAKE_PAGE(occur) Child, VGroup, \ 
  140.                             MUIA_Weight, 120, \
  141.                             Child, ColGroup(2), GroupFrame, \
  142.                                 Child, Label1(GetString(&li, MSG_Vendor)), \
  143.                                 Child, Sl_Vendor[occur] = TextObject, \
  144.                                     TextFrame, \
  145.                                     MUIA_Text_SetMax, FALSE, \
  146.                                 End, \
  147.                                 Child, Label1(GetString(&li, MSG_Product)), \
  148.                                 Child, Sl_Product[occur] = TextObject, \ 
  149.                                     TextFrame, \
  150.                                     MUIA_Text_SetMax, FALSE, \
  151.                                 End, \
  152.                                 Child, Label1(GetString(&li, MSG_Revision)), \
  153.                                 Child, Sl_Revision[occur] = TextObject, \
  154.                                     TextFrame, \
  155.                                     MUIA_Text_SetMax, FALSE, \
  156.                                 End, \
  157.                                 Child, Label1(GetString(&li, MSG_Device_Type)), \
  158.                                 Child, Sl_DevType[occur] = TextObject, \
  159.                                     TextFrame, \
  160.                                     MUIA_Text_SetMax, FALSE, \
  161.                                 End, \
  162.                                 Child, Label1(GetString(&li, MSG_Standard)), \                                    
  163.                                 Child, Sl_Standard[occur] = TextObject, \
  164.                                     TextFrame, \
  165.                                     MUIA_Text_SetMax, FALSE, \
  166.                                 End, \
  167.                             End, \ 
  168.                             Child, ColGroup(4), GroupFrame, \
  169.                                 Child, Label1(GetString(&li, MSG_Removable)), \
  170.                                 Child, Sl_Removable[occur] = ImageObject, \
  171.                                     MUIA_InputMode, MUIV_InputMode_None, \
  172.                                     MUIA_Selected, FALSE, \
  173.                                     MUIA_Background, MUII_ButtonBack,\
  174.                                     MUIA_Image_Spec, MUII_CheckMark, \
  175.                                 End, \
  176.                                 Child, Label1(GetString(&li, MSG_Rel_Addr)), \
  177.                                 Child, Sl_Rel_Addr[occur] = ImageObject, \
  178.                                     MUIA_InputMode, MUIV_InputMode_None, \
  179.                                     MUIA_Selected, FALSE, \
  180.                                     MUIA_Background, MUII_ButtonBack,\
  181.                                     MUIA_Image_Spec, MUII_CheckMark, \
  182.                                 End, \
  183.                                 Child, Label1(GetString(&li, MSG_16_Wide)), \
  184.                                 Child, Sl_16Wide_Addr[occur] = ImageObject, \
  185.                                     MUIA_InputMode, MUIV_InputMode_None, \
  186.                                     MUIA_Selected, FALSE, \
  187.                                     MUIA_Background, MUII_ButtonBack,\
  188.                                     MUIA_Image_Spec, MUII_CheckMark, \
  189.                                 End, \
  190.                                 Child, Label1(GetString(&li, MSG_32_Wide)), \
  191.                                 Child, Sl_32Wide_Addr[occur] = ImageObject, \
  192.                                     MUIA_InputMode, MUIV_InputMode_None, \
  193.                                     MUIA_Selected, FALSE, \
  194.                                     MUIA_Background, MUII_ButtonBack,\
  195.                                     MUIA_Image_Spec, MUII_CheckMark, \
  196.                                 End, \
  197.                             End, \
  198.                         End, 
  199.  
  200.  
  201. /*------------------------------------------------------------------------*/
  202.  
  203. struct  MUI_CustomClass         *CL_ScsiList;
  204. struct  LocaleInfo              li;
  205.  
  206. APTR    app;
  207. APTR    win1;
  208. APTR    aboutwin;
  209. enum    { ID_OK = 1, ID_SELECT = 2, ID_File};
  210. static  APTR    lv_tools;
  211. static  APTR    lv_scsi;
  212. static  APTR    tx_device;
  213. static  APTR    pg_group;
  214. /* char    *text    = "Ok"; */
  215. BOOL    FromWb              = FALSE;
  216. char    *scsidevice = "scsi.device                              ";
  217. int     scsiunit = 7;
  218. struct  ScsiList_Data
  219. {
  220.     Object  *SL_OImage_CD;
  221.     Object  *SL_OImage_HD;
  222.     Object  *SL_OImage_RD;
  223.     Object  *SL_OImage_SC;
  224.     Object  *SL_OImage_NO;
  225.     Object  *SL_OImage_NL;
  226.     APTR    SL_Image_CD;
  227.     APTR    SL_Image_HD;
  228.     APTR    SL_Image_RD;
  229.     APTR    SL_Image_SC;
  230.     APTR    SL_Image_NO;
  231.     APTR    SL_Image_NL;
  232.     struct  Hook    DisplayHook;
  233. };
  234. struct  ScsiUnitData
  235. {
  236.     int     SUD_Unit;           /*  Unit Id Number                        */
  237.     char    *SUD_Vendor;        /*  Vendor Name                           */
  238.     char    *SUD_Product;       /*  Product Name                          */
  239.     char    *SUD_Revision;      /*  Product Revision Id                   */
  240.     int     SUD_Dev_type;       /*  Type of Device                        */
  241.     int     SUD_Standard;       /*  Device Standard                       */
  242.     BOOL    SUD_Removable;      /*  Removable Media ?                     */
  243.     BOOL    SUD_Rel_Addr;       /*  Relative Addressing ?                 */
  244.     BOOL    SUD_16Wide_Addr;    /*  16 Bit Wide Addressing ?              */
  245.     BOOL    SUD_32Wide_Addr;    /*  16 Bit Wide Addressing ?              */
  246. };
  247. struct  Device      *scsi_dev;
  248. struct  MsgPort     *replymp;
  249. struct  IOStdReq    *scsi_req;
  250. struct  SCSICmd     scsi_cmd;
  251. struct  Node        *DeviceLibNode;
  252. UBYTE               *scsi_sense;
  253. UBYTE               *scsi_data      = NULL;
  254. static  UBYTE       cmd[] = { SCSI_CMD_INQ, 0, 0, 0, 252, 0, };
  255. static  char        *Units[] = { "List", "0", "1", "2", "3", "4", "5", "6", NULL };
  256. static  APTR        Sl_Product[8];
  257. static  APTR        Sl_Vendor[8];
  258. static  APTR        Sl_Revision[8];
  259. static  APTR        Sl_DevType[8];
  260. static  APTR        Sl_Standard[8];
  261. static  APTR        Sl_Removable[8];
  262. static  APTR        Sl_Rel_Addr[8];
  263. static  APTR        Sl_16Wide_Addr[8];
  264. static  APTR        Sl_32Wide_Addr[8];
  265.  
  266. /*------------------------------------------------------------------------*/
  267.  
  268. ULONG __stdargs DoSuperNew(struct IClass *cl,Object *obj,ULONG tag1,...)
  269. {
  270.     return(DoSuperMethod(cl,obj,OM_NEW,&tag1,NULL));
  271. }
  272.  
  273. /*------------------------------------------------------------------------*/
  274.  
  275. void main(int argc, char **argv)
  276. {
  277.     struct  WBStartup   *WBenchMsg;
  278.     struct  WBArg       *wbarg;
  279.     ULONG   signals;
  280.     BOOL    running = TRUE;
  281.     LONG    olddir;
  282.     ULONG   c_pos;
  283.  
  284.     if (!(li.li_LocaleBase = LocaleBase = OpenLibrary("locale.library",0L)))
  285.         BailOut(NULL, "Unable to open locale.library");
  286.     
  287.     if ((IconBase = OpenLibrary("icon.library",0L)) == NULL)
  288.         BailOut(NULL, GetString(&li, MSG_Unable_to_Open_icon));
  289.     
  290.     FromWb  = (argc==0) ?   TRUE : FALSE;
  291.  
  292.     if (FromWb)
  293.     {
  294.         WBenchMsg = (struct WBStartup *)argv;
  295.         wbarg = WBenchMsg->sm_ArgList;
  296.         olddir = -1;
  297.         if ((wbarg->wa_Lock) && (*wbarg->wa_Name))
  298.             olddir = CurrentDir(wbarg->wa_Lock);
  299.         gettooltypes(wbarg);
  300.         if (olddir != -1)
  301.            CurrentDir(olddir); /*  CD back where we were           */
  302.     }
  303.        
  304.     li.li_Catalog = OpenCatalog(NULL, "Scsi_List.catalog", TAG_DONE);
  305.     
  306.     if (!(MUIMasterBase = OpenLibrary(MUIMASTER_NAME,MUIMASTER_VMIN)))
  307.         BailOut(NULL, GetString(&li, MSG_Unable_to_Open_MUI));
  308.  
  309.     if (!(InitClasses()))
  310.         BailOut(NULL, GetString(&li, MSG_Unable_to_Create_Cust_Class));
  311.         
  312.     app = ApplicationObject,
  313.             MUIA_Application_Title,         "Scsi Identifier",            
  314.             MUIA_Application_Version,       "$VER: Scsi_Identifier 1.2 (7.4.96)",
  315.             MUIA_Application_Copyright,     "@1996, Richard Sellens",
  316.             MUIA_Application_Author,        "Richard Sellens",
  317.             MUIA_Application_Description,   "Show SCSI Devices",
  318.             MUIA_Application_Base,          "SCSI",
  319.             
  320.             MUIA_Application_Window, win1 = WindowObject,
  321.                 MUIA_Window_Title, "Scsi Identifier",
  322.                 MUIA_Window_ID   , MAKE_ID('S','C','S','I'),
  323.  
  324.                 WindowContents, VGroup,
  325.                     Child, HGroup, GroupFrame,
  326.                         MUIA_Weight, 100,
  327.                         Child, BodychunkObject, MUIA_FixWidth, SCSI_WIDTH,
  328.                                  MUIA_FixHeight, SCSI_HEIGHT,
  329.                                  MUIA_Bitmap_Width, SCSI_WIDTH,
  330.                                  MUIA_Bitmap_Height, SCSI_HEIGHT,
  331.                                  MUIA_Bodychunk_Depth, SCSI_DEPTH,
  332.                                  MUIA_Bodychunk_Body, (UBYTE *)Scsi_body,
  333.                                  MUIA_Bodychunk_Compression, SCSI_COMPRESSION,
  334.                                  MUIA_Bodychunk_Masking, SCSI_MASKING,
  335.                                  MUIA_Bitmap_SourceColors, (ULONG *)Scsi_colors,
  336.                                  MUIA_Bitmap_Transparent, 0,
  337.                         End,
  338.                         Child, ColGroup(2),
  339.                             Child, Label1(GetString(&li, MSG_Device)),
  340.                             Child, tx_device = TextObject,
  341.                                  TextFrame,
  342.                                  MUIA_Text_SetMax, FALSE,
  343.                             End,
  344.                         End,
  345.                     End,  
  346.                     Child, pg_group = RegisterGroup(Units),
  347.                         MUIA_Register_Frame, TRUE,
  348.                         Child, lv_tools = ListviewObject,
  349.                             MUIA_Weight, 120,
  350.                             MUIA_CycleChain, 1,
  351.                             MUIA_Listview_Input, TRUE,
  352.                             ReadListFrame,
  353.                             MUIA_Listview_List, lv_scsi = NewObject(CL_ScsiList->mcc_Class, NULL, TAG_DONE),
  354.                         End,
  355.                         MAKE_PAGE(1)
  356.                         MAKE_PAGE(2)
  357.                         MAKE_PAGE(3)
  358.                         MAKE_PAGE(4)
  359.                         MAKE_PAGE(5)
  360.                         MAKE_PAGE(6)
  361.                         MAKE_PAGE(7)
  362.                     End,  
  363.                 End,
  364.             End,
  365.         End;
  366.        
  367.     if (!app)
  368.         BailOut(app, GetString(&li, MSG_Failed_to_Create_App));
  369.     
  370.     DoMethod(win1, MUIM_Notify, MUIA_Window_CloseRequest, TRUE,
  371.         app,2,MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit); 
  372.     DoMethod(lv_tools, MUIM_Notify,MUIA_Listview_DoubleClick,TRUE,app,2, MUIM_Application_ReturnID, ID_SELECT); 
  373.     
  374.     set(tx_device, MUIA_Text_Contents, scsidevice); 
  375.     set(win1, MUIA_Window_Open, TRUE);
  376.     
  377.     ShowSCSI(scsidevice);
  378.     
  379.     while (running)
  380.     { 
  381.         ULONG id = DoMethod(app, MUIM_Application_NewInput, &signals);
  382.         switch (id)
  383.         {
  384.             case MUIV_Application_ReturnID_Quit:
  385.                 running = FALSE;
  386.                 break;
  387.             case ID_SELECT:
  388.                 get(lv_tools, MUIA_List_Active, &c_pos);
  389.                 set(pg_group, MUIA_Group_ActivePage, (c_pos + 1)); 
  390.                 break;
  391.             case ID_OK:
  392.                 break;
  393.         }
  394.         if (running && signals)
  395.             Wait(signals);
  396.     }
  397.     
  398.     set(win1, MUIA_Window_Open, FALSE);
  399.     BailOut(app, NULL);
  400. }
  401.  
  402. /*------------------------------------------------------------------------*/
  403.  
  404. void BailOut(APTR app, char *str)
  405. {
  406.     if (app)
  407.         MUI_DisposeObject(app);
  408.  
  409.     ExitClasses();
  410.  
  411.     if (MUIMasterBase)
  412.         CloseLibrary(MUIMasterBase);
  413.     
  414.     if (LocaleBase)
  415.     {
  416.         CloseCatalog(li.li_Catalog);
  417.         CloseLibrary(LocaleBase);
  418.     }
  419.     
  420.     if (IconBase)
  421.         CloseLibrary(IconBase);
  422.     
  423.     if (str)
  424.     {
  425.         puts(str);
  426.         exit(20);
  427.     }
  428.     
  429.     exit(0);    
  430. }
  431.  
  432. /*------------------------------------------------------------------------*/
  433.  
  434. void gettooltypes(struct WBArg *wbarg)
  435. {
  436.     struct  DiskObject  *dobj;
  437.     char    **toolarray;
  438.     char    *s;
  439.  
  440.     if ((*wbarg->wa_Name) && (dobj = GetDiskObject(wbarg->wa_Name)))
  441.     {
  442.         toolarray = (char **)dobj->do_ToolTypes;
  443.         if (s = (char *)FindToolType(toolarray, "DEVICE"))
  444.         {
  445.             strcpy(scsidevice,s);
  446.         }
  447.         FreeDiskObject(dobj);
  448.     }
  449.        
  450.     return;   
  451. }
  452.  
  453. /*------------------------------------------------------------------------*/
  454.  
  455. SAVEDS ASM ULONG ScsiList_Dispatcher(REG(a0) struct IClass *cl,REG(a2) Object *obj,REG(a1) Msg msg)
  456. {
  457.     switch (msg->MethodID)
  458.     {
  459.         case OM_NEW              : return(ScsiList_New    (cl,obj,(APTR)msg));
  460.         case MUIM_Setup          : return(ScsiList_Setup  (cl,obj,(APTR)msg));
  461.         case MUIM_Cleanup        : return(ScsiList_Cleanup(cl,obj,(APTR)msg));
  462.     }
  463.     return(DoSuperMethodA(cl,obj,msg));
  464. }
  465.  
  466. /*------------------------------------------------------------------------*/
  467.  
  468. SAVEDS ASM APTR ScsiList_ConstructFunc(REG(a1) struct ScsiUnitData *SLCF_src)
  469. {
  470.     struct ScsiUnitData *SLCF_dest = (struct ScsiUnitData *)AllocMem(sizeof(struct ScsiUnitData), MEMF_ANY|MEMF_CLEAR);
  471.  
  472.     SLCF_dest->SUD_Vendor = (char *)AllocMem(10, MEMF_ANY|MEMF_CLEAR);
  473.        SLCF_dest->SUD_Product = (char *)AllocMem(18, MEMF_ANY|MEMF_CLEAR);
  474.     SLCF_dest->SUD_Revision = (char *)AllocMem(6, MEMF_ANY|MEMF_CLEAR); 
  475.  
  476.     SLCF_dest->SUD_Unit = SLCF_src->SUD_Unit;
  477.     strcpy(SLCF_dest->SUD_Vendor, SLCF_src->SUD_Vendor);
  478.     strcpy(SLCF_dest->SUD_Product, SLCF_src->SUD_Product);
  479.     strcpy(SLCF_dest->SUD_Revision, SLCF_src->SUD_Revision);
  480.     SLCF_dest->SUD_Dev_type = SLCF_src->SUD_Dev_type;
  481.     SLCF_dest->SUD_Standard = SLCF_src->SUD_Standard;
  482.     SLCF_dest->SUD_Removable = SLCF_src->SUD_Removable;
  483.     SLCF_dest->SUD_Rel_Addr = SLCF_src->SUD_Rel_Addr;
  484.     SLCF_dest->SUD_16Wide_Addr = SLCF_src->SUD_16Wide_Addr;
  485.     SLCF_dest->SUD_32Wide_Addr = SLCF_src->SUD_32Wide_Addr;
  486.      
  487.     return(SLCF_dest);
  488. }
  489.  
  490. /*------------------------------------------------------------------------*/
  491.  
  492. SAVEDS ASM VOID ScsiList_DestructFunc(REG(a1) struct ScsiUnitData *SLDF_data)
  493. {
  494.     FreeMem(SLDF_data->SUD_Vendor, 10);
  495.     FreeMem(SLDF_data->SUD_Product, 18);
  496.     FreeMem(SLDF_data->SUD_Revision, 6); 
  497.     
  498.     FreeMem(SLDF_data, sizeof(struct ScsiUnitData));
  499. }
  500.  
  501. /*------------------------------------------------------------------------*/
  502.  
  503. SAVEDS ASM LONG ScsiList_DisplayFunc(REG(a0) struct Hook *hook,REG(a2) char **array, REG(a1) struct ScsiUnitData *data1)
  504. {
  505.     struct ScsiList_Data *data = (APTR)hook->h_Data;
  506.     static char buf1[50], buf2[30], buf3[30];
  507.     
  508.     *array++ = "";
  509.     
  510.     if (!data1)
  511.     {
  512.         strcpy(buf2,"\33b\33u");
  513.         strcpy(buf3,"\33b\33u");
  514.         strcat(buf2, GetString(&li, MSG_Unit));
  515.         strcat(buf3, GetString(&li, MSG_Product));
  516.         *array++ = "";
  517.         *array++ = buf2;
  518.         *array   = buf3;
  519.     }
  520.     else
  521.     {
  522.         switch(data1->SUD_Dev_type)
  523.         {
  524.             case 0:
  525.                 if (data1->SUD_Removable)
  526.                     sprintf(buf1, "\33O[%08lx]", data->SL_Image_RD);
  527.                 else
  528.                     sprintf(buf1, "\33O[%08lx]", data->SL_Image_HD);
  529.                 break;
  530.             case 5:
  531.                 sprintf(buf1, "\33O[%08lx]", data->SL_Image_CD);
  532.                 break;
  533.             case 6:
  534.                 sprintf(buf1, "\33O[%08lx]", data->SL_Image_SC);
  535.                 break;
  536.             case 99:
  537.                 sprintf(buf1, "\33O[%08lx]", data->SL_Image_NO);
  538.                 break; 
  539.             default:
  540.                 sprintf(buf1, "\33O[%08lx]", data->SL_Image_NL);
  541.                 break;
  542.         }
  543.         sprintf(buf2, "%d", data1->SUD_Unit);
  544.         strcpy(buf3, data1->SUD_Product);
  545.         *array++ = buf1;
  546.         *array++ = buf2;
  547.         *array   = buf3;
  548.     }
  549.     
  550.     return(0);
  551. }
  552.  
  553. /*------------------------------------------------------------------------*/
  554.  
  555. ULONG ScsiList_New(struct IClass *cl,Object *obj,struct opSet *msg)
  556. {
  557.     static const struct Hook ScsiList_ConstructHook = { { 0,0 }, (VOID *)ScsiList_ConstructFunc, NULL, NULL};
  558.     static const struct Hook ScsiList_DestructHook  = { { 0,0 }, (VOID *)ScsiList_DestructFunc, NULL, NULL};
  559.  
  560.     obj=(Object *)DoSuperNew(cl,obj,
  561.         MUIA_List_ConstructHook, &ScsiList_ConstructHook, 
  562.         MUIA_List_DestructHook , &ScsiList_DestructHook,
  563.         MUIA_List_Format       , ",,,",
  564.         MUIA_List_Title        , TRUE,
  565.         MUIA_List_MinLineHeight, 14, 
  566.         TAG_MORE,msg->ops_AttrList);
  567.  
  568.     if (obj)
  569.     {
  570.         struct ScsiList_Data *data = INST_DATA(cl,obj);
  571.  
  572.         data->DisplayHook.h_Entry = (VOID *)ScsiList_DisplayFunc;
  573.         data->DisplayHook.h_Data  = (APTR)data;
  574.  
  575.         set(obj,MUIA_List_DisplayHook,&data->DisplayHook);
  576.     }
  577.  
  578.     return((ULONG)obj);
  579.     
  580. }
  581.  
  582. /*------------------------------------------------------------------------*/
  583.  
  584. static Object *makescsiimage(UBYTE *body)
  585. {
  586.     Object *obj = BodychunkObject,
  587.         MUIA_FixWidth             , CD_ROM_WIDTH ,
  588.         MUIA_FixHeight            , CD_ROM_HEIGHT,
  589.         MUIA_Bitmap_Width         , CD_ROM_WIDTH ,
  590.         MUIA_Bitmap_Height        , CD_ROM_HEIGHT,
  591.         MUIA_Bodychunk_Depth      , CD_ROM_DEPTH ,
  592.         MUIA_Bodychunk_Body       , (UBYTE *)body,
  593.         MUIA_Bodychunk_Compression, CD_ROM_COMPRESSION,
  594.         MUIA_Bodychunk_Masking    , CD_ROM_MASKING,
  595.         MUIA_Bitmap_SourceColors  , (ULONG *)CD_Rom_colors,
  596.         MUIA_Bitmap_Transparent   , 0,
  597.         End;
  598.  
  599.     return(obj);
  600. }
  601.  
  602. /*------------------------------------------------------------------------*/
  603.  
  604. static Object *makescsiimageSC(UBYTE *body)
  605. {
  606.     Object *obj = BodychunkObject,
  607.         MUIA_FixWidth             , SCANNER_WIDTH ,
  608.         MUIA_FixHeight            , SCANNER_HEIGHT,
  609.         MUIA_Bitmap_Width         , SCANNER_WIDTH ,
  610.         MUIA_Bitmap_Height        , SCANNER_HEIGHT,
  611.         MUIA_Bodychunk_Depth      , SCANNER_DEPTH ,
  612.         MUIA_Bodychunk_Body       , (UBYTE *)body,
  613.         MUIA_Bodychunk_Compression, SCANNER_COMPRESSION,
  614.         MUIA_Bodychunk_Masking    , SCANNER_MASKING,
  615.         MUIA_Bitmap_SourceColors  , (ULONG *)Scanner_colors,
  616.         MUIA_Bitmap_Transparent   , 0,
  617.         End;
  618.  
  619.     return(obj);
  620. }
  621.  
  622. /*------------------------------------------------------------------------*/
  623.  
  624. ULONG ScsiList_Setup(struct IClass *cl,Object *obj,Msg msg)
  625. {
  626.     struct ScsiList_Data *data = INST_DATA(cl,obj);
  627.  
  628.     if (!DoSuperMethodA(cl,obj,msg))
  629.         return(FALSE);
  630.  
  631.     data->SL_OImage_CD = makescsiimage((UBYTE *)CD_Rom_body);
  632.     data->SL_OImage_HD = makescsiimage((UBYTE *)Hard_Drive_body);
  633.     data->SL_OImage_RD = makescsiimage((UBYTE *)Remove_Drive_body);
  634.     data->SL_OImage_SC = makescsiimageSC((UBYTE *)Scanner_body);
  635.     data->SL_OImage_NO = makescsiimage((UBYTE *)NoUnit_body); 
  636.     data->SL_OImage_NL = makescsiimage((UBYTE *)Null_body);
  637.  
  638.     data->SL_Image_CD = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->SL_OImage_CD ,0);
  639.     data->SL_Image_HD = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->SL_OImage_HD ,0);
  640.     data->SL_Image_RD = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->SL_OImage_RD ,0);
  641.     data->SL_Image_SC = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->SL_OImage_SC ,0);
  642.     data->SL_Image_NO = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->SL_OImage_NO ,0); 
  643.     data->SL_Image_NL = (APTR)DoMethod(obj,MUIM_List_CreateImage,data->SL_OImage_NL ,0);
  644.  
  645.     MUI_RequestIDCMP(obj,IDCMP_MOUSEBUTTONS);
  646.  
  647.     return(TRUE);
  648. }
  649.  
  650. /*------------------------------------------------------------------------*/
  651.  
  652. ULONG ScsiList_Cleanup(struct IClass *cl,Object *obj,Msg msg)
  653. {
  654.     struct ScsiList_Data *data = INST_DATA(cl,obj);
  655.  
  656.     DoMethod(obj,MUIM_List_DeleteImage,data->SL_Image_CD);
  657.     DoMethod(obj,MUIM_List_DeleteImage,data->SL_Image_HD);
  658.     DoMethod(obj,MUIM_List_DeleteImage,data->SL_Image_RD);
  659.     DoMethod(obj,MUIM_List_DeleteImage,data->SL_Image_SC);
  660.     DoMethod(obj,MUIM_List_DeleteImage,data->SL_Image_NO); 
  661.     DoMethod(obj,MUIM_List_DeleteImage,data->SL_Image_NL);
  662.  
  663.     MUI_RejectIDCMP(obj,IDCMP_MOUSEBUTTONS);
  664.  
  665.     return(DoSuperMethodA(cl,obj,msg));
  666. }
  667.  
  668. /*------------------------------------------------------------------------*/
  669.  
  670. BOOL InitClasses(VOID)
  671. {
  672.     CL_ScsiList   = MUI_CreateCustomClass(NULL, MUIC_List, NULL, sizeof(struct ScsiList_Data), ScsiList_Dispatcher);
  673.  
  674.     if (CL_ScsiList)
  675.         return(TRUE);
  676.  
  677.     ExitClasses();
  678.     return(FALSE);
  679. }
  680.  
  681. /*------------------------------------------------------------------------*/
  682.  
  683. VOID ExitClasses(VOID)
  684. {
  685.     if (CL_ScsiList) 
  686.         MUI_DeleteCustomClass(CL_ScsiList);
  687. }
  688.  
  689. /*------------------------------------------------------------------------*/
  690.  
  691. void ShowSCSI(char *SSdevice)
  692. {
  693.     if (!(scsi_sense = (UBYTE *)AllocMem(252, MEMF_CHIP|MEMF_CLEAR)))
  694.         ShowScsi_exit(20, GetString(&li, MSG_Unable_to_Allocate_Memory));
  695.  
  696.     if (!(scsi_data = (UBYTE *)AllocMem(252, MEMF_CHIP|MEMF_CLEAR)))
  697.         ShowScsi_exit(20, GetString(&li, MSG_Unable_to_Allocate_Memory));
  698.  
  699.     if (!(replymp = (struct MsgPort *)CreatePort(NULL, 0)))
  700.         ShowScsi_exit(20, GetString(&li, MSG_Unable_to_Create_Mess_Port));
  701.         
  702.     if (!(scsi_req = (struct IOStdReq *)CreateStdIO(replymp)))
  703.         ShowScsi_exit(20, GetString(&li, MSG_Unable_to_Create_StandardIO));
  704.     
  705.     ListDevices(SSdevice); 
  706.     
  707.     ShowScsi_exit(0, NULL);
  708. }
  709.  
  710. /*------------------------------------------------------------------------*/
  711.  
  712. void ShowScsi_exit(long code, char *errmsg)
  713. {
  714.     if (scsi_req)
  715.         DeleteStdIO(scsi_req);
  716.     
  717.     if (replymp)
  718.         DeletePort(replymp);
  719.     
  720.     if (scsi_sense)
  721.         FreeMem(scsi_sense, 252);
  722.     
  723.     if (scsi_data)
  724.         FreeMem(scsi_data, 252);
  725.     
  726.     if (errmsg)
  727.         printf("\n%s\n", errmsg);
  728.     
  729.     return;
  730. }
  731.  
  732. /*------------------------------------------------------------------------*/
  733.  
  734. void ListDevices(char *devname)
  735. {
  736.     int i;
  737.     struct ScsiUnitData *SUdata = (struct ScsiUnitData *)AllocMem(sizeof(struct ScsiUnitData), MEMF_ANY|MEMF_CLEAR);
  738.  
  739.     SUdata->SUD_Vendor = (char *)AllocMem(10, MEMF_ANY|MEMF_CLEAR);
  740.     SUdata->SUD_Product = (char *)AllocMem(18, MEMF_ANY|MEMF_CLEAR);
  741.     SUdata->SUD_Revision = (char *)AllocMem(6, MEMF_ANY|MEMF_CLEAR);
  742.             
  743.     set(lv_tools, MUIA_List_Quiet, TRUE);
  744.     for (i = 0; i < scsiunit; i++)
  745.     {
  746.         SUdata->SUD_Unit = i;    
  747.         if (OpenDevice(devname, i, scsi_req, 0))
  748.         {
  749.             strcpy(SUdata->SUD_Vendor, " ");
  750.             strcpy(SUdata->SUD_Product, GetString(&li, MSG_Not_Used));
  751.             strcpy(SUdata->SUD_Revision, " ");
  752.             SUdata->SUD_Dev_type = 99;
  753.             SUdata->SUD_Standard = 9;
  754.             SUdata->SUD_Removable = FALSE;
  755.             SUdata->SUD_Rel_Addr = FALSE;
  756.             SUdata->SUD_16Wide_Addr = FALSE;
  757.             SUdata->SUD_32Wide_Addr = FALSE;
  758.         }
  759.         else
  760.         {
  761.             scsi_req->io_Length         = sizeof(struct SCSICmd);
  762.             scsi_req->io_Data           = (APTR) &scsi_cmd;
  763.             scsi_req->io_Command        = HD_SCSICMD;
  764.             scsi_cmd.scsi_Data          = (APTR) scsi_data;
  765.             scsi_cmd.scsi_Length        = 252;
  766.             scsi_cmd.scsi_SenseActual   = 0;
  767.             scsi_cmd.scsi_SenseData     = scsi_sense;
  768.             scsi_cmd.scsi_SenseLength   = 252;
  769.             scsi_cmd.scsi_Command       = (UBYTE *)cmd;
  770.             scsi_cmd.scsi_CmdLength     = sizeof(cmd);
  771.             scsi_cmd.scsi_Flags         = SCSIF_READ|SCSIF_AUTOSENSE;
  772.     
  773.             DoIO((struct IOStdReq *)scsi_req);
  774.             
  775.             
  776.             if (scsi_req->io_Error)
  777.             { 
  778.                 strcpy(SUdata->SUD_Vendor," ");
  779.                 strcpy(SUdata->SUD_Product, GetString(&li, MSG_Not_Used));
  780.                 strcpy(SUdata->SUD_Revision, " ");
  781.                 SUdata->SUD_Dev_type = 99;
  782.                 SUdata->SUD_Standard = 9;
  783.                 SUdata->SUD_Removable = FALSE;
  784.                 SUdata->SUD_Rel_Addr = FALSE;
  785.                 SUdata->SUD_16Wide_Addr = FALSE;
  786.                 SUdata->SUD_32Wide_Addr = FALSE;
  787.             }
  788.             else
  789.             {
  790.                 sprintf(SUdata->SUD_Vendor, "%.8s", &scsi_data[8]);
  791.                 sprintf(SUdata->SUD_Product, "%.16s", &scsi_data[16]);
  792.                 sprintf(SUdata->SUD_Revision, "%.4s", &scsi_data[32]);
  793.                 SUdata->SUD_Dev_type = (scsi_data[0] & 0x1F);
  794.                 SUdata->SUD_Standard = (scsi_data[3] & 0x0F);
  795.                 SUdata->SUD_Removable = ((scsi_data[1] & 0x80) ? TRUE : FALSE); 
  796.                 SUdata->SUD_Rel_Addr = ((scsi_data[7] & 0x80) ? TRUE : FALSE); 
  797.                 SUdata->SUD_16Wide_Addr = ((scsi_data[7] & 0x20) ? TRUE : FALSE); 
  798.                 SUdata->SUD_32Wide_Addr = ((scsi_data[7] & 0x40) ? TRUE : FALSE);
  799.             }
  800.             CloseDevice(scsi_req);
  801.         } 
  802.         DoMethod(lv_tools, MUIM_List_InsertSingle, SUdata, MUIV_List_Insert_Bottom);
  803.         set(Sl_Product[i+1], MUIA_Text_Contents, SUdata->SUD_Product);
  804.         set(Sl_Vendor[i+1], MUIA_Text_Contents, SUdata->SUD_Vendor);
  805.         set(Sl_Revision[i+1], MUIA_Text_Contents, SUdata->SUD_Revision);
  806.         set(Sl_DevType[i+1], MUIA_Text_Contents, id2string(SUdata->SUD_Dev_type, devicetype));
  807.         set(Sl_Standard[i+1], MUIA_Text_Contents, id2string(SUdata->SUD_Standard, responseformat));
  808.         set(Sl_Removable[i+1], MUIA_Selected, SUdata->SUD_Removable);
  809.         set(Sl_Rel_Addr[i+1], MUIA_Selected, SUdata->SUD_Rel_Addr);
  810.         set(Sl_16Wide_Addr[i+1], MUIA_Selected, SUdata->SUD_16Wide_Addr);
  811.         set(Sl_32Wide_Addr[i+1], MUIA_Selected, SUdata->SUD_32Wide_Addr);
  812.     }
  813.     set(lv_tools, MUIA_List_Quiet, FALSE);  
  814.     
  815.     FreeMem(SUdata->SUD_Vendor, 10);
  816.     FreeMem(SUdata->SUD_Product, 18);
  817.     FreeMem(SUdata->SUD_Revision, 6);
  818.     
  819.     FreeMem(SUdata, sizeof(struct ScsiUnitData));
  820. }
  821.  
  822. /*------------------------------------------------------------------------*/
  823.  
  824. UBYTE *id2string(int id, IDTOSTRING * idtable)
  825. {
  826.   int j = 0;
  827.   UBYTE *p;
  828.  
  829.   do
  830.   {
  831.     p = idtable[j].ptr;
  832.     if (idtable[j].code == id)
  833.         break;
  834.   } 
  835.   while (idtable[j++].code != -1);
  836.   
  837.   return p;
  838. }
  839.  
  840.